{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-title"
    ]
   },
   "source": [
    "# Softmax exercise\n",
    "\n",
    "*Complete and hand in this completed worksheet (including its outputs and any supporting code outside of the worksheet) with your assignment submission. For more details see the [assignments page](http://vision.stanford.edu/teaching/cs231n/assignments.html) on the course website.*\n",
    "\n",
    "This exercise is analogous to the SVM exercise. You will:\n",
    "\n",
    "- implement a fully-vectorized **loss function** for the Softmax classifier\n",
    "- implement the fully-vectorized expression for its **analytic gradient**\n",
    "- **check your implementation** with numerical gradient\n",
    "- use a validation set to **tune the learning rate and regularization** strength\n",
    "- **optimize** the loss function with **SGD**\n",
    "- **visualize** the final learned weights\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "from cs231n.data_utils import load_CIFAR10\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading extenrnal modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train data shape:  (49000, 3073)\n",
      "Train labels shape:  (49000,)\n",
      "Validation data shape:  (1000, 3073)\n",
      "Validation labels shape:  (1000,)\n",
      "Test data shape:  (1000, 3073)\n",
      "Test labels shape:  (1000,)\n",
      "dev data shape:  (500, 3073)\n",
      "dev labels shape:  (500,)\n"
     ]
    }
   ],
   "source": [
    "def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000, num_dev=500):\n",
    "    \"\"\"\n",
    "    Load the CIFAR-10 dataset from disk and perform preprocessing to prepare\n",
    "    it for the linear classifier. These are the same steps as we used for the\n",
    "    SVM, but condensed to a single function.  \n",
    "    \"\"\"\n",
    "    # Load the raw CIFAR-10 data\n",
    "    cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\n",
    "    \n",
    "    # Cleaning up variables to prevent loading data multiple times (which may cause memory issue)\n",
    "    try:\n",
    "       del X_train, y_train\n",
    "       del X_test, y_test\n",
    "       print('Clear previously loaded data.')\n",
    "    except:\n",
    "       pass\n",
    "\n",
    "    X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n",
    "    \n",
    "    # subsample the data\n",
    "    mask = list(range(num_training, num_training + num_validation))\n",
    "    X_val = X_train[mask]\n",
    "    y_val = y_train[mask]\n",
    "    mask = list(range(num_training))\n",
    "    X_train = X_train[mask]\n",
    "    y_train = y_train[mask]\n",
    "    mask = list(range(num_test))\n",
    "    X_test = X_test[mask]\n",
    "    y_test = y_test[mask]\n",
    "    mask = np.random.choice(num_training, num_dev, replace=False)\n",
    "    X_dev = X_train[mask]\n",
    "    y_dev = y_train[mask]\n",
    "    \n",
    "    # Preprocessing: reshape the image data into rows\n",
    "    X_train = np.reshape(X_train, (X_train.shape[0], -1))\n",
    "    X_val = np.reshape(X_val, (X_val.shape[0], -1))\n",
    "    X_test = np.reshape(X_test, (X_test.shape[0], -1))\n",
    "    X_dev = np.reshape(X_dev, (X_dev.shape[0], -1))\n",
    "    \n",
    "    # Normalize the data: subtract the mean image\n",
    "    mean_image = np.mean(X_train, axis = 0)\n",
    "    X_train -= mean_image\n",
    "    X_val -= mean_image\n",
    "    X_test -= mean_image\n",
    "    X_dev -= mean_image\n",
    "    \n",
    "    # add bias dimension and transform into columns\n",
    "    X_train = np.hstack([X_train, np.ones((X_train.shape[0], 1))])\n",
    "    X_val = np.hstack([X_val, np.ones((X_val.shape[0], 1))])\n",
    "    X_test = np.hstack([X_test, np.ones((X_test.shape[0], 1))])\n",
    "    X_dev = np.hstack([X_dev, np.ones((X_dev.shape[0], 1))])\n",
    "    \n",
    "    return X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev\n",
    "\n",
    "\n",
    "# Invoke the above function to get our data.\n",
    "X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev = get_CIFAR10_data()\n",
    "print('Train data shape: ', X_train.shape)\n",
    "print('Train labels shape: ', y_train.shape)\n",
    "print('Validation data shape: ', X_val.shape)\n",
    "print('Validation labels shape: ', y_val.shape)\n",
    "print('Test data shape: ', X_test.shape)\n",
    "print('Test labels shape: ', y_test.shape)\n",
    "print('dev data shape: ', X_dev.shape)\n",
    "print('dev labels shape: ', y_dev.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Softmax Classifier\n",
    "\n",
    "Your code for this section will all be written inside **cs231n/classifiers/softmax.py**. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss: 2.360004\n",
      "sanity check: 2.302585\n"
     ]
    }
   ],
   "source": [
    "# First implement the naive softmax loss function with nested loops.\n",
    "# Open the file cs231n/classifiers/softmax.py and implement the\n",
    "# softmax_loss_naive function.\n",
    "\n",
    "from cs231n.classifiers.softmax import softmax_loss_naive\n",
    "import time\n",
    "\n",
    "# Generate a random softmax weight matrix and use it to compute the loss.\n",
    "W = np.random.randn(3073, 10) * 0.0001\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n",
    "\n",
    "# As a rough sanity check, our loss should be something close to -log(0.1).\n",
    "print('loss: %f' % loss)\n",
    "print('sanity check: %f' % (-np.log(0.1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "**Inline Question 1**\n",
    "\n",
    "Why do we expect our loss to be close to -log(0.1)? Explain briefly.**\n",
    "\n",
    "$\\color{blue}{\\textit Your Answer:}$ *Fill this in* \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "numerical: 2.140543 analytic: 2.140543, relative error: 5.111640e-10\n",
      "numerical: -1.933647 analytic: -1.933648, relative error: 2.216810e-08\n",
      "numerical: 0.004043 analytic: 0.004043, relative error: 3.225706e-06\n",
      "numerical: -3.515015 analytic: -3.515015, relative error: 4.457751e-09\n",
      "numerical: 1.906883 analytic: 1.906883, relative error: 2.703359e-09\n",
      "numerical: 1.487025 analytic: 1.487025, relative error: 9.148736e-09\n",
      "numerical: 0.932812 analytic: 0.932812, relative error: 2.493695e-08\n",
      "numerical: -0.629241 analytic: -0.629242, relative error: 1.421009e-07\n",
      "numerical: 0.968139 analytic: 0.968139, relative error: 7.059468e-08\n",
      "numerical: 1.764673 analytic: 1.764673, relative error: 1.051203e-08\n",
      "numerical: 1.708793 analytic: 1.708792, relative error: 1.175762e-08\n",
      "numerical: 1.949863 analytic: 1.949863, relative error: 2.601447e-08\n",
      "numerical: -3.761676 analytic: -3.761676, relative error: 3.296890e-09\n",
      "numerical: -3.006476 analytic: -3.006476, relative error: 2.773451e-08\n",
      "numerical: 1.580328 analytic: 1.580328, relative error: 3.471600e-09\n",
      "numerical: -1.831307 analytic: -1.831307, relative error: 2.004202e-09\n",
      "numerical: 1.704504 analytic: 1.704504, relative error: 2.201859e-08\n",
      "numerical: -1.220415 analytic: -1.220415, relative error: 6.029412e-09\n",
      "numerical: -1.533430 analytic: -1.533430, relative error: 2.381305e-08\n",
      "numerical: 3.054014 analytic: 3.054014, relative error: 3.831275e-08\n"
     ]
    }
   ],
   "source": [
    "# Complete the implementation of softmax_loss_naive and implement a (naive)\n",
    "# version of the gradient that uses nested loops.\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n",
    "\n",
    "# As we did for the SVM, use numeric gradient checking as a debugging tool.\n",
    "# The numeric gradient should be close to the analytic gradient.\n",
    "from cs231n.gradient_check import grad_check_sparse\n",
    "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 0.0)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad, 10)\n",
    "\n",
    "# similar to SVM case, do another gradient check with regularization\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 5e1)\n",
    "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 5e1)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "公式推导\n",
    "$$\n",
    "t = y_i\\\\\n",
    "L' = p_{ij}\\cdot s'_j-s'_t\\\\\n",
    "L' = \n",
    "\\begin{cases}\n",
    "p_{ij}\\cdot x_j &, j\\ne t\\\\\n",
    "(p_{it}-1)\\cdot x_t &, j = t\n",
    "\\end{cases}\\\\\n",
    "X^T = [x_0, x_1, \\cdots, x_N]\\\\\n",
    "P = \n",
    "\\begin{bmatrix}\n",
    "p_0\\\\p_1\\\\\\vdots\\\\p_C\n",
    "\\end{bmatrix}\\\\\n",
    "$$\n",
    "对于每一个样本i：\n",
    "$$\n",
    "dW = x_i^T\\cdot p_i\\\\\n",
    "dW[:t] -= 1\n",
    "$$\n",
    "所以，预先把$p_i$中正确样本的值减1，然后：\n",
    "$$\n",
    "dW = X^T\\cdot P\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "naive loss: 2.360004e+00 computed in 0.050184s\n",
      "vectorized loss: 2.360004e+00 computed in 0.007357s\n",
      "Loss difference: 0.000000\n",
      "Gradient difference: 0.000000\n"
     ]
    }
   ],
   "source": [
    "# Now that we have a naive implementation of the softmax loss function and its gradient,\n",
    "# implement a vectorized version in softmax_loss_vectorized.\n",
    "# The two versions should compute the same results, but the vectorized version should be\n",
    "# much faster.\n",
    "tic = time.time()\n",
    "loss_naive, grad_naive = softmax_loss_naive(W, X_dev, y_dev, 0.000005)\n",
    "toc = time.time()\n",
    "print('naive loss: %e computed in %fs' % (loss_naive, toc - tic))\n",
    "\n",
    "from cs231n.classifiers.softmax import softmax_loss_vectorized\n",
    "tic = time.time()\n",
    "loss_vectorized, grad_vectorized = softmax_loss_vectorized(W, X_dev, y_dev, 0.000005)\n",
    "toc = time.time()\n",
    "print('vectorized loss: %e computed in %fs' % (loss_vectorized, toc - tic))\n",
    "\n",
    "# As we did for the SVM, we use the Frobenius norm to compare the two versions\n",
    "# of the gradient.\n",
    "grad_difference = np.linalg.norm(grad_naive - grad_vectorized, ord='fro')\n",
    "print('Loss difference: %f' % np.abs(loss_naive - loss_vectorized))\n",
    "print('Gradient difference: %f' % grad_difference)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "tags": [
     "code"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lr 1.000000e-07 reg 2.500000e+04 train accuracy: 0.328265 val accuracy: 0.343000\n",
      "lr 1.000000e-07 reg 5.000000e+04 train accuracy: 0.309184 val accuracy: 0.324000\n",
      "lr 5.000000e-07 reg 2.500000e+04 train accuracy: 0.332959 val accuracy: 0.352000\n",
      "lr 5.000000e-07 reg 5.000000e+04 train accuracy: 0.305000 val accuracy: 0.321000\n",
      "best validation accuracy achieved during cross-validation: 0.352000\n"
     ]
    }
   ],
   "source": [
    "# Use the validation set to tune hyperparameters (regularization strength and\n",
    "# learning rate). You should experiment with different ranges for the learning\n",
    "# rates and regularization strengths; if you are careful you should be able to\n",
    "# get a classification accuracy of over 0.35 on the validation set.\n",
    "from cs231n.classifiers import Softmax\n",
    "results = {}\n",
    "best_val = -1\n",
    "best_softmax = None\n",
    "learning_rates = [1e-7, 5e-7]\n",
    "regularization_strengths = [2.5e4, 5e4]\n",
    "\n",
    "################################################################################\n",
    "# TODO:                                                                        #\n",
    "# Use the validation set to set the learning rate and regularization strength. #\n",
    "# This should be identical to the validation that you did for the SVM; save    #\n",
    "# the best trained softmax classifer in best_softmax.                          #\n",
    "################################################################################\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "\n",
    "for lr in learning_rates:\n",
    "    for reg in regularization_strengths:\n",
    "        softmax = Softmax()\n",
    "        loss_hist = softmax.train(X_train, y_train, learning_rate=lr, reg=reg,\n",
    "                      num_iters=1500, batch_size=200, verbose=False)\n",
    "        y_train_pred = softmax.predict(X_train)\n",
    "        acc_train = np.mean(y_train == y_train_pred)\n",
    "        y_val_pred = softmax.predict(X_val)\n",
    "        acc_val = np.mean(y_val == y_val_pred)\n",
    "        results[(lr, reg)] = (acc_train, acc_val)\n",
    "        if acc_val > best_val:\n",
    "            best_softmax = softmax\n",
    "            best_val = acc_val\n",
    "\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "    \n",
    "# Print out results.\n",
    "for lr, reg in sorted(results):\n",
    "    train_accuracy, val_accuracy = results[(lr, reg)]\n",
    "    print('lr %e reg %e train accuracy: %f val accuracy: %f' % (\n",
    "                lr, reg, train_accuracy, val_accuracy))\n",
    "    \n",
    "print('best validation accuracy achieved during cross-validation: %f' % best_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "softmax on raw pixels final test set accuracy: 0.335000\n"
     ]
    }
   ],
   "source": [
    "# evaluate on test set\n",
    "# Evaluate the best softmax on test set\n",
    "y_test_pred = best_softmax.predict(X_test)\n",
    "test_accuracy = np.mean(y_test == y_test_pred)\n",
    "print('softmax on raw pixels final test set accuracy: %f' % (test_accuracy, ))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "**Inline Question 2** - *True or False*\n",
    "\n",
    "Suppose the overall training loss is defined as the sum of the per-datapoint loss over all training examples. It is possible to add a new datapoint to a training set that would leave the SVM loss unchanged, but this is not the case with the Softmax classifier loss.\n",
    "\n",
    "$\\color{blue}{\\textit Your Answer:}$\n",
    "True\n",
    "\n",
    "$\\color{blue}{\\textit Your Explanation:}$\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize the learned weights for each class\n",
    "w = best_softmax.W[:-1,:] # strip out the bias\n",
    "w = w.reshape(32, 32, 3, 10)\n",
    "\n",
    "w_min, w_max = np.min(w), np.max(w)\n",
    "\n",
    "classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n",
    "for i in range(10):\n",
    "    plt.subplot(2, 5, i + 1)\n",
    "    \n",
    "    # Rescale the weights to be between 0 and 255\n",
    "    wimg = 255.0 * (w[:, :, :, i].squeeze() - w_min) / (w_max - w_min)\n",
    "    plt.imshow(wimg.astype('uint8'))\n",
    "    plt.axis('off')\n",
    "    plt.title(classes[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
